
from constantes import *
import random

class Dados(object):
	"""Implementa la logica de tirar los dados."""

	def __init__(self):
		"""Inicializacion del objeto."""
		self.dados_atacante=[]
		self.dados_atacado=[]
		self.ejercitos_perdio_atacante=0
		self.ejercitos_perdio_atacado=0

	def __str__(self):
		"""Representacion de la configuracion de dados de la ultima
		tirada."""
		return "El atacante obtuvo %s en sus dados, el atacado obtuvo %s." %(str(self.dados_atacante),str(self.dados_atacado))
	
	def lanzar_dados(self, ejercitos_atacante, ejercitos_atacado):
		"""Recibe la cantidad de ejercitos presentes en el pais
		atacante y en el pais atacado. Realiza la tirada de los dados.
		El pais que ataca tiene que tener al menos dos ejercitos.
		El pais que ataca ataca con hasta un dado menos que los
		ejercitos que posee, mientras que el pais que defiende lo
		hace hasta con tantos dados como ejercitos.
		La cantidad maxima de dados con la que un pais ataca o defiende
		es siempre 3.
		Cada jugador tira sus dados.
		Los mismos se ordenan de mayor a menor.
		Si un jugador tiro mas dados que otro, los de menor valor se
		descartan.
		Se comparan uno a uno los dados ordenados.
		Cuando el valor de un dado atacante fuera *mayor* que el del
		atacado, el atacado pierde un ejercito. Si no, el atacante lo
		pierde.
		(Leer el reglamento del juego.)"""
		#cada vez que se lanzan los dados borra la tirada anterior
		self.dados_atacante=[]
		self.dados_atacado=[]
		self.ejercitos_perdio_atacante=0
		self.ejercitos_perdio_atacado=0

		#Asigna un valor de 1 a 3 que son los ejercitos que efectivamente realizan el ataque
		if ejercitos_atacante>3:
			dados_atacante=3 
		else:	
			dados_atacante=ejercitos_atacante-1
		if ejercitos_atacado>3:
			dados_atacado=3
		else:
			dados_atacado=ejercitos_atacado

		#Agrega un valor al azar entre 1 y 6 que es el resultado de cada tirada de dados	
		self.dados_atacante=genera_lista_random(dados_atacante)
		self.dados_atacado=genera_lista_random(dados_atacado)

		#Descarta los dados de mas en el que mas dados tiene
		if len(self.dados_atacante)>len(self.dados_atacado):
			for x in range(len(self.dados_atacante)-len(self.dados_atacado)):
				self.dados_atacante.pop()
		elif len(self.dados_atacante)<len(self.dados_atacado):
			for x in range(len(self.dados_atacado)-len(self.dados_atacante)):
				self.dados_atacado.pop()

		#Calcula cuantos ejercitos perdio cada uno		
		for x in range(len(self.dados_atacado)):
			if self.dados_atacante[x]>self.dados_atacado[x]:
				self.ejercitos_perdio_atacado+=1
			else:
				self.ejercitos_perdio_atacante+=1

	def ejercitos_perdidos_atacante(self):
		"""Devuelve la cantidad de ejercitos que perdio el atacante en
		la ultima tirada de dados."""
		return self.ejercitos_perdio_atacante
		
	def ejercitos_perdidos_atacado(self):
		"""Devuelve la cantidad de ejercitos que perdio el atacado en
		la ultima tirada de dados."""
		return self.ejercitos_perdio_atacado

	
def genera_lista_random(largo):
	'''Genera una lista de largo recibido por parametro con numeros enteros del 1 al 6 ordenados de mayor a menor
	'''
	lista=list()
	for x in range(largo):
		lista.append(random.randint(1,6))
	lista.sort(None,None,True)
	return lista
